home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / compiler / pycodegen.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  48.0 KB  |  1,631 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import imp
  5. import os
  6. import marshal
  7. import struct
  8. import sys
  9. import types
  10. from cStringIO import StringIO
  11. from compiler import ast, parse, walk, syntax
  12. from compiler import pyassem, misc, future, symbols
  13. from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL
  14. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS, CO_NEWLOCALS, CO_NESTED, CO_GENERATOR, CO_GENERATOR_ALLOWED, CO_FUTURE_DIVISION
  15. from compiler.pyassem import TupleArg
  16.  
  17. try:
  18.     VERSION = sys.version_info[0]
  19. except AttributeError:
  20.     VERSION = 1
  21.  
  22. callfunc_opcode_info = {
  23.     (0, 0): 'CALL_FUNCTION',
  24.     (1, 0): 'CALL_FUNCTION_VAR',
  25.     (0, 1): 'CALL_FUNCTION_KW',
  26.     (1, 1): 'CALL_FUNCTION_VAR_KW' }
  27. LOOP = 1
  28. EXCEPT = 2
  29. TRY_FINALLY = 3
  30. END_FINALLY = 4
  31.  
  32. def compileFile(filename, display = 0):
  33.     f = open(filename, 'U')
  34.     buf = f.read()
  35.     f.close()
  36.     mod = Module(buf, filename)
  37.     
  38.     try:
  39.         mod.compile(display)
  40.     except SyntaxError:
  41.         raise 
  42.  
  43.     f = open(filename + 'c', 'wb')
  44.     mod.dump(f)
  45.     f.close()
  46.  
  47.  
  48. def compile(source, filename, mode, flags = None, dont_inherit = None):
  49.     '''Replacement for builtin compile() function'''
  50.     if flags is not None or dont_inherit is not None:
  51.         raise RuntimeError, 'not implemented yet'
  52.     
  53.     if mode == 'single':
  54.         gen = Interactive(source, filename)
  55.     elif mode == 'exec':
  56.         gen = Module(source, filename)
  57.     elif mode == 'eval':
  58.         gen = Expression(source, filename)
  59.     else:
  60.         raise ValueError("compile() 3rd arg must be 'exec' or 'eval' or 'single'")
  61.     gen.compile()
  62.     return gen.code
  63.  
  64.  
  65. class AbstractCompileMode:
  66.     mode = None
  67.     
  68.     def __init__(self, source, filename):
  69.         self.source = source
  70.         self.filename = filename
  71.         self.code = None
  72.  
  73.     
  74.     def _get_tree(self):
  75.         tree = parse(self.source, self.mode)
  76.         misc.set_filename(self.filename, tree)
  77.         syntax.check(tree)
  78.         return tree
  79.  
  80.     
  81.     def compile(self):
  82.         pass
  83.  
  84.     
  85.     def getCode(self):
  86.         return self.code
  87.  
  88.  
  89.  
  90. class Expression(AbstractCompileMode):
  91.     mode = 'eval'
  92.     
  93.     def compile(self):
  94.         tree = self._get_tree()
  95.         gen = ExpressionCodeGenerator(tree)
  96.         self.code = gen.getCode()
  97.  
  98.  
  99.  
  100. class Interactive(AbstractCompileMode):
  101.     mode = 'single'
  102.     
  103.     def compile(self):
  104.         tree = self._get_tree()
  105.         gen = InteractiveCodeGenerator(tree)
  106.         self.code = gen.getCode()
  107.  
  108.  
  109.  
  110. class Module(AbstractCompileMode):
  111.     mode = 'exec'
  112.     
  113.     def compile(self, display = 0):
  114.         tree = self._get_tree()
  115.         gen = ModuleCodeGenerator(tree)
  116.         if display:
  117.             import pprint
  118.             print pprint.pprint(tree)
  119.         
  120.         self.code = gen.getCode()
  121.  
  122.     
  123.     def dump(self, f):
  124.         f.write(self.getPycHeader())
  125.         marshal.dump(self.code, f)
  126.  
  127.     MAGIC = imp.get_magic()
  128.     
  129.     def getPycHeader(self):
  130.         mtime = os.path.getmtime(self.filename)
  131.         mtime = struct.pack('<i', mtime)
  132.         return self.MAGIC + mtime
  133.  
  134.  
  135.  
  136. class LocalNameFinder:
  137.     '''Find local names in scope'''
  138.     
  139.     def __init__(self, names = ()):
  140.         self.names = misc.Set()
  141.         self.globals = misc.Set()
  142.         for name in names:
  143.             self.names.add(name)
  144.         
  145.  
  146.     
  147.     def getLocals(self):
  148.         for elt in self.globals.elements():
  149.             if self.names.has_elt(elt):
  150.                 self.names.remove(elt)
  151.                 continue
  152.         
  153.         return self.names
  154.  
  155.     
  156.     def visitDict(self, node):
  157.         pass
  158.  
  159.     
  160.     def visitGlobal(self, node):
  161.         for name in node.names:
  162.             self.globals.add(name)
  163.         
  164.  
  165.     
  166.     def visitFunction(self, node):
  167.         self.names.add(node.name)
  168.  
  169.     
  170.     def visitLambda(self, node):
  171.         pass
  172.  
  173.     
  174.     def visitImport(self, node):
  175.         for name, alias in node.names:
  176.             if not alias:
  177.                 pass
  178.             self.names.add(name)
  179.         
  180.  
  181.     
  182.     def visitFrom(self, node):
  183.         for name, alias in node.names:
  184.             if not alias:
  185.                 pass
  186.             self.names.add(name)
  187.         
  188.  
  189.     
  190.     def visitClass(self, node):
  191.         self.names.add(node.name)
  192.  
  193.     
  194.     def visitAssName(self, node):
  195.         self.names.add(node.name)
  196.  
  197.  
  198.  
  199. def is_constant_false(node):
  200.     if isinstance(node, ast.Const):
  201.         if not node.value:
  202.             return 1
  203.         
  204.     
  205.     return 0
  206.  
  207.  
  208. class CodeGenerator:
  209.     '''Defines basic code generator for Python bytecode
  210.  
  211.     This class is an abstract base class.  Concrete subclasses must
  212.     define an __init__() that defines self.graph and then calls the
  213.     __init__() defined in this class.
  214.  
  215.     The concrete class must also define the class attributes
  216.     NameFinder, FunctionGen, and ClassGen.  These attributes can be
  217.     defined in the initClass() method, which is a hook for
  218.     initializing these methods after all the classes have been
  219.     defined.
  220.     '''
  221.     optimized = 0
  222.     __initialized = None
  223.     class_name = None
  224.     
  225.     def __init__(self):
  226.         if self._CodeGenerator__initialized is None:
  227.             self.initClass()
  228.             self.__class__._CodeGenerator__initialized = 1
  229.         
  230.         self.checkClass()
  231.         self.locals = misc.Stack()
  232.         self.setups = misc.Stack()
  233.         self.last_lineno = None
  234.         self._setupGraphDelegation()
  235.         self._div_op = 'BINARY_DIVIDE'
  236.         futures = self.get_module().futures
  237.         for feature in futures:
  238.             if feature == 'division':
  239.                 self.graph.setFlag(CO_FUTURE_DIVISION)
  240.                 self._div_op = 'BINARY_TRUE_DIVIDE'
  241.                 continue
  242.             if feature == 'generators':
  243.                 self.graph.setFlag(CO_GENERATOR_ALLOWED)
  244.                 continue
  245.         
  246.  
  247.     
  248.     def initClass(self):
  249.         '''This method is called once for each class'''
  250.         pass
  251.  
  252.     
  253.     def checkClass(self):
  254.         '''Verify that class is constructed correctly'''
  255.         
  256.         try:
  257.             pass
  258.         except AssertionError:
  259.             msg = None
  260.             intro = 'Bad class construction for %s' % self.__class__.__name__
  261.             raise AssertionError, intro
  262.  
  263.  
  264.     
  265.     def _setupGraphDelegation(self):
  266.         self.emit = self.graph.emit
  267.         self.newBlock = self.graph.newBlock
  268.         self.startBlock = self.graph.startBlock
  269.         self.nextBlock = self.graph.nextBlock
  270.         self.setDocstring = self.graph.setDocstring
  271.  
  272.     
  273.     def getCode(self):
  274.         '''Return a code object'''
  275.         return self.graph.getCode()
  276.  
  277.     
  278.     def mangle(self, name):
  279.         if self.class_name is not None:
  280.             return misc.mangle(name, self.class_name)
  281.         else:
  282.             return name
  283.  
  284.     
  285.     def parseSymbols(self, tree):
  286.         s = symbols.SymbolVisitor()
  287.         walk(tree, s)
  288.         return s.scopes
  289.  
  290.     
  291.     def get_module(self):
  292.         raise RuntimeError, 'should be implemented by subclasses'
  293.  
  294.     
  295.     def isLocalName(self, name):
  296.         return self.locals.top().has_elt(name)
  297.  
  298.     
  299.     def storeName(self, name):
  300.         self._nameOp('STORE', name)
  301.  
  302.     
  303.     def loadName(self, name):
  304.         self._nameOp('LOAD', name)
  305.  
  306.     
  307.     def delName(self, name):
  308.         self._nameOp('DELETE', name)
  309.  
  310.     
  311.     def _nameOp(self, prefix, name):
  312.         name = self.mangle(name)
  313.         scope = self.scope.check_name(name)
  314.         if scope == SC_LOCAL:
  315.             if not self.optimized:
  316.                 self.emit(prefix + '_NAME', name)
  317.             else:
  318.                 self.emit(prefix + '_FAST', name)
  319.         elif scope == SC_GLOBAL:
  320.             if not self.optimized:
  321.                 self.emit(prefix + '_NAME', name)
  322.             else:
  323.                 self.emit(prefix + '_GLOBAL', name)
  324.         elif scope == SC_FREE or scope == SC_CELL:
  325.             self.emit(prefix + '_DEREF', name)
  326.         else:
  327.             raise RuntimeError, 'unsupported scope for var %s: %d' % (name, scope)
  328.  
  329.     
  330.     def _implicitNameOp(self, prefix, name):
  331.         """Emit name ops for names generated implicitly by for loops
  332.  
  333.         The interpreter generates names that start with a period or
  334.         dollar sign.  The symbol table ignores these names because
  335.         they aren't present in the program text.
  336.         """
  337.         if self.optimized:
  338.             self.emit(prefix + '_FAST', name)
  339.         else:
  340.             self.emit(prefix + '_NAME', name)
  341.  
  342.     
  343.     def set_lineno(self, node, force = False):
  344.         '''Emit SET_LINENO if necessary.
  345.  
  346.         The instruction is considered necessary if the node has a
  347.         lineno attribute and it is different than the last lineno
  348.         emitted.
  349.  
  350.         Returns true if SET_LINENO was emitted.
  351.  
  352.         There are no rules for when an AST node should have a lineno
  353.         attribute.  The transformer and AST code need to be reviewed
  354.         and a consistent policy implemented and documented.  Until
  355.         then, this method works around missing line numbers.
  356.         '''
  357.         lineno = getattr(node, 'lineno', None)
  358.         if lineno is not None:
  359.             if lineno != self.last_lineno or force:
  360.                 self.emit('SET_LINENO', lineno)
  361.                 self.last_lineno = lineno
  362.                 return True
  363.             
  364.         return False
  365.  
  366.     NameFinder = LocalNameFinder
  367.     FunctionGen = None
  368.     ClassGen = None
  369.     
  370.     def visitModule(self, node):
  371.         self.scopes = self.parseSymbols(node)
  372.         self.scope = self.scopes[node]
  373.         self.emit('SET_LINENO', 0)
  374.         if node.doc:
  375.             self.emit('LOAD_CONST', node.doc)
  376.             self.storeName('__doc__')
  377.         
  378.         lnf = walk(node.node, self.NameFinder(), verbose = 0)
  379.         self.locals.push(lnf.getLocals())
  380.         self.visit(node.node)
  381.         self.emit('LOAD_CONST', None)
  382.         self.emit('RETURN_VALUE')
  383.  
  384.     
  385.     def visitExpression(self, node):
  386.         self.set_lineno(node)
  387.         self.scopes = self.parseSymbols(node)
  388.         self.scope = self.scopes[node]
  389.         self.visit(node.node)
  390.         self.emit('RETURN_VALUE')
  391.  
  392.     
  393.     def visitFunction(self, node):
  394.         self._visitFuncOrLambda(node, isLambda = 0)
  395.         if node.doc:
  396.             self.setDocstring(node.doc)
  397.         
  398.         self.storeName(node.name)
  399.  
  400.     
  401.     def visitLambda(self, node):
  402.         self._visitFuncOrLambda(node, isLambda = 1)
  403.  
  404.     
  405.     def _visitFuncOrLambda(self, node, isLambda = 0):
  406.         if not isLambda and node.decorators:
  407.             for decorator in node.decorators.nodes:
  408.                 self.visit(decorator)
  409.             
  410.             ndecorators = len(node.decorators.nodes)
  411.         else:
  412.             ndecorators = 0
  413.         gen = self.FunctionGen(node, self.scopes, isLambda, self.class_name, self.get_module())
  414.         walk(node.code, gen)
  415.         gen.finish()
  416.         self.set_lineno(node)
  417.         for default in node.defaults:
  418.             self.visit(default)
  419.         
  420.         frees = gen.scope.get_free_vars()
  421.         if frees:
  422.             for name in frees:
  423.                 self.emit('LOAD_CLOSURE', name)
  424.             
  425.             self.emit('LOAD_CONST', gen)
  426.             self.emit('MAKE_CLOSURE', len(node.defaults))
  427.         else:
  428.             self.emit('LOAD_CONST', gen)
  429.             self.emit('MAKE_FUNCTION', len(node.defaults))
  430.         for i in range(ndecorators):
  431.             self.emit('CALL_FUNCTION', 1)
  432.         
  433.  
  434.     
  435.     def visitClass(self, node):
  436.         gen = self.ClassGen(node, self.scopes, self.get_module())
  437.         walk(node.code, gen)
  438.         gen.finish()
  439.         self.set_lineno(node)
  440.         self.emit('LOAD_CONST', node.name)
  441.         for base in node.bases:
  442.             self.visit(base)
  443.         
  444.         self.emit('BUILD_TUPLE', len(node.bases))
  445.         frees = gen.scope.get_free_vars()
  446.         for name in frees:
  447.             self.emit('LOAD_CLOSURE', name)
  448.         
  449.         self.emit('LOAD_CONST', gen)
  450.         if frees:
  451.             self.emit('MAKE_CLOSURE', 0)
  452.         else:
  453.             self.emit('MAKE_FUNCTION', 0)
  454.         self.emit('CALL_FUNCTION', 0)
  455.         self.emit('BUILD_CLASS')
  456.         self.storeName(node.name)
  457.  
  458.     
  459.     def visitIf(self, node):
  460.         end = self.newBlock()
  461.         numtests = len(node.tests)
  462.         for i in range(numtests):
  463.             (test, suite) = node.tests[i]
  464.             if is_constant_false(test):
  465.                 continue
  466.             
  467.             self.set_lineno(test)
  468.             self.visit(test)
  469.             nextTest = self.newBlock()
  470.             self.emit('JUMP_IF_FALSE', nextTest)
  471.             self.nextBlock()
  472.             self.emit('POP_TOP')
  473.             self.visit(suite)
  474.             self.emit('JUMP_FORWARD', end)
  475.             self.startBlock(nextTest)
  476.             self.emit('POP_TOP')
  477.         
  478.         if node.else_:
  479.             self.visit(node.else_)
  480.         
  481.         self.nextBlock(end)
  482.  
  483.     
  484.     def visitWhile(self, node):
  485.         self.set_lineno(node)
  486.         loop = self.newBlock()
  487.         else_ = self.newBlock()
  488.         after = self.newBlock()
  489.         self.emit('SETUP_LOOP', after)
  490.         self.nextBlock(loop)
  491.         self.setups.push((LOOP, loop))
  492.         self.set_lineno(node, force = True)
  493.         self.visit(node.test)
  494.         if not else_:
  495.             pass
  496.         self.emit('JUMP_IF_FALSE', after)
  497.         self.nextBlock()
  498.         self.emit('POP_TOP')
  499.         self.visit(node.body)
  500.         self.emit('JUMP_ABSOLUTE', loop)
  501.         self.startBlock(else_)
  502.         self.emit('POP_TOP')
  503.         self.emit('POP_BLOCK')
  504.         self.setups.pop()
  505.         if node.else_:
  506.             self.visit(node.else_)
  507.         
  508.         self.nextBlock(after)
  509.  
  510.     
  511.     def visitFor(self, node):
  512.         start = self.newBlock()
  513.         anchor = self.newBlock()
  514.         after = self.newBlock()
  515.         self.setups.push((LOOP, start))
  516.         self.set_lineno(node)
  517.         self.emit('SETUP_LOOP', after)
  518.         self.visit(node.list)
  519.         self.emit('GET_ITER')
  520.         self.nextBlock(start)
  521.         self.set_lineno(node, force = 1)
  522.         self.emit('FOR_ITER', anchor)
  523.         self.visit(node.assign)
  524.         self.visit(node.body)
  525.         self.emit('JUMP_ABSOLUTE', start)
  526.         self.nextBlock(anchor)
  527.         self.emit('POP_BLOCK')
  528.         self.setups.pop()
  529.         if node.else_:
  530.             self.visit(node.else_)
  531.         
  532.         self.nextBlock(after)
  533.  
  534.     
  535.     def visitBreak(self, node):
  536.         if not self.setups:
  537.             raise SyntaxError, "'break' outside loop (%s, %d)" % (node.filename, node.lineno)
  538.         
  539.         self.set_lineno(node)
  540.         self.emit('BREAK_LOOP')
  541.  
  542.     
  543.     def visitContinue(self, node):
  544.         if not self.setups:
  545.             raise SyntaxError, "'continue' outside loop (%s, %d)" % (node.filename, node.lineno)
  546.         
  547.         (kind, block) = self.setups.top()
  548.         if kind == LOOP:
  549.             self.set_lineno(node)
  550.             self.emit('JUMP_ABSOLUTE', block)
  551.             self.nextBlock()
  552.         elif kind == EXCEPT or kind == TRY_FINALLY:
  553.             self.set_lineno(node)
  554.             top = len(self.setups)
  555.             while top > 0:
  556.                 top = top - 1
  557.                 (kind, loop_block) = self.setups[top]
  558.                 if kind == LOOP:
  559.                     break
  560.                     continue
  561.             if kind != LOOP:
  562.                 raise SyntaxError, "'continue' outside loop (%s, %d)" % (node.filename, node.lineno)
  563.             
  564.             self.emit('CONTINUE_LOOP', loop_block)
  565.             self.nextBlock()
  566.         elif kind == END_FINALLY:
  567.             msg = "'continue' not allowed inside 'finally' clause (%s, %d)"
  568.             raise SyntaxError, msg % (node.filename, node.lineno)
  569.         
  570.  
  571.     
  572.     def visitTest(self, node, jump):
  573.         end = self.newBlock()
  574.         for child in node.nodes[:-1]:
  575.             self.visit(child)
  576.             self.emit(jump, end)
  577.             self.nextBlock()
  578.             self.emit('POP_TOP')
  579.         
  580.         self.visit(node.nodes[-1])
  581.         self.nextBlock(end)
  582.  
  583.     
  584.     def visitAnd(self, node):
  585.         self.visitTest(node, 'JUMP_IF_FALSE')
  586.  
  587.     
  588.     def visitOr(self, node):
  589.         self.visitTest(node, 'JUMP_IF_TRUE')
  590.  
  591.     
  592.     def visitCompare(self, node):
  593.         self.visit(node.expr)
  594.         cleanup = self.newBlock()
  595.         for op, code in node.ops[:-1]:
  596.             self.visit(code)
  597.             self.emit('DUP_TOP')
  598.             self.emit('ROT_THREE')
  599.             self.emit('COMPARE_OP', op)
  600.             self.emit('JUMP_IF_FALSE', cleanup)
  601.             self.nextBlock()
  602.             self.emit('POP_TOP')
  603.         
  604.         if node.ops:
  605.             (op, code) = node.ops[-1]
  606.             self.visit(code)
  607.             self.emit('COMPARE_OP', op)
  608.         
  609.         if len(node.ops) > 1:
  610.             end = self.newBlock()
  611.             self.emit('JUMP_FORWARD', end)
  612.             self.startBlock(cleanup)
  613.             self.emit('ROT_TWO')
  614.             self.emit('POP_TOP')
  615.             self.nextBlock(end)
  616.         
  617.  
  618.     __list_count = 0
  619.     
  620.     def visitListComp(self, node):
  621.         self.set_lineno(node)
  622.         append = '$append%d' % self._CodeGenerator__list_count
  623.         self._CodeGenerator__list_count = self._CodeGenerator__list_count + 1
  624.         self.emit('BUILD_LIST', 0)
  625.         self.emit('DUP_TOP')
  626.         self.emit('LOAD_ATTR', 'append')
  627.         self._implicitNameOp('STORE', append)
  628.         stack = []
  629.         for i, for_ in zip(range(len(node.quals)), node.quals):
  630.             (start, anchor) = self.visit(for_)
  631.             cont = None
  632.             for if_ in for_.ifs:
  633.                 if cont is None:
  634.                     cont = self.newBlock()
  635.                 
  636.                 self.visit(if_, cont)
  637.             
  638.             stack.insert(0, (start, cont, anchor))
  639.         
  640.         self._implicitNameOp('LOAD', append)
  641.         self.visit(node.expr)
  642.         self.emit('CALL_FUNCTION', 1)
  643.         self.emit('POP_TOP')
  644.         for start, cont, anchor in stack:
  645.             if cont:
  646.                 skip_one = self.newBlock()
  647.                 self.emit('JUMP_FORWARD', skip_one)
  648.                 self.startBlock(cont)
  649.                 self.emit('POP_TOP')
  650.                 self.nextBlock(skip_one)
  651.             
  652.             self.emit('JUMP_ABSOLUTE', start)
  653.             self.startBlock(anchor)
  654.         
  655.         self._implicitNameOp('DELETE', append)
  656.         self._CodeGenerator__list_count = self._CodeGenerator__list_count - 1
  657.  
  658.     
  659.     def visitListCompFor(self, node):
  660.         start = self.newBlock()
  661.         anchor = self.newBlock()
  662.         self.visit(node.list)
  663.         self.emit('GET_ITER')
  664.         self.nextBlock(start)
  665.         self.set_lineno(node, force = True)
  666.         self.emit('FOR_ITER', anchor)
  667.         self.nextBlock()
  668.         self.visit(node.assign)
  669.         return (start, anchor)
  670.  
  671.     
  672.     def visitListCompIf(self, node, branch):
  673.         self.set_lineno(node, force = True)
  674.         self.visit(node.test)
  675.         self.emit('JUMP_IF_FALSE', branch)
  676.         self.newBlock()
  677.         self.emit('POP_TOP')
  678.  
  679.     
  680.     def visitGenExpr(self, node):
  681.         gen = GenExprCodeGenerator(node, self.scopes, self.class_name, self.get_module())
  682.         walk(node.code, gen)
  683.         gen.finish()
  684.         self.set_lineno(node)
  685.         frees = gen.scope.get_free_vars()
  686.         if frees:
  687.             for name in frees:
  688.                 self.emit('LOAD_CLOSURE', name)
  689.             
  690.             self.emit('LOAD_CONST', gen)
  691.             self.emit('MAKE_CLOSURE', 0)
  692.         else:
  693.             self.emit('LOAD_CONST', gen)
  694.             self.emit('MAKE_FUNCTION', 0)
  695.         self.visit(node.code.quals[0].iter)
  696.         self.emit('GET_ITER')
  697.         self.emit('CALL_FUNCTION', 1)
  698.  
  699.     
  700.     def visitGenExprInner(self, node):
  701.         self.set_lineno(node)
  702.         stack = []
  703.         for i, for_ in zip(range(len(node.quals)), node.quals):
  704.             (start, anchor) = self.visit(for_)
  705.             cont = None
  706.             for if_ in for_.ifs:
  707.                 if cont is None:
  708.                     cont = self.newBlock()
  709.                 
  710.                 self.visit(if_, cont)
  711.             
  712.             stack.insert(0, (start, cont, anchor))
  713.         
  714.         self.visit(node.expr)
  715.         self.emit('YIELD_VALUE')
  716.         for start, cont, anchor in stack:
  717.             if cont:
  718.                 skip_one = self.newBlock()
  719.                 self.emit('JUMP_FORWARD', skip_one)
  720.                 self.startBlock(cont)
  721.                 self.emit('POP_TOP')
  722.                 self.nextBlock(skip_one)
  723.             
  724.             self.emit('JUMP_ABSOLUTE', start)
  725.             self.startBlock(anchor)
  726.         
  727.         self.emit('LOAD_CONST', None)
  728.  
  729.     
  730.     def visitGenExprFor(self, node):
  731.         start = self.newBlock()
  732.         anchor = self.newBlock()
  733.         if node.is_outmost:
  734.             self.loadName('[outmost-iterable]')
  735.         else:
  736.             self.visit(node.iter)
  737.             self.emit('GET_ITER')
  738.         self.nextBlock(start)
  739.         self.set_lineno(node, force = True)
  740.         self.emit('FOR_ITER', anchor)
  741.         self.nextBlock()
  742.         self.visit(node.assign)
  743.         return (start, anchor)
  744.  
  745.     
  746.     def visitGenExprIf(self, node, branch):
  747.         self.set_lineno(node, force = True)
  748.         self.visit(node.test)
  749.         self.emit('JUMP_IF_FALSE', branch)
  750.         self.newBlock()
  751.         self.emit('POP_TOP')
  752.  
  753.     
  754.     def visitAssert(self, node):
  755.         pass
  756.  
  757.     
  758.     def visitRaise(self, node):
  759.         self.set_lineno(node)
  760.         n = 0
  761.         if node.expr1:
  762.             self.visit(node.expr1)
  763.             n = n + 1
  764.         
  765.         if node.expr2:
  766.             self.visit(node.expr2)
  767.             n = n + 1
  768.         
  769.         if node.expr3:
  770.             self.visit(node.expr3)
  771.             n = n + 1
  772.         
  773.         self.emit('RAISE_VARARGS', n)
  774.  
  775.     
  776.     def visitTryExcept(self, node):
  777.         body = self.newBlock()
  778.         handlers = self.newBlock()
  779.         end = self.newBlock()
  780.         if node.else_:
  781.             lElse = self.newBlock()
  782.         else:
  783.             lElse = end
  784.         self.set_lineno(node)
  785.         self.emit('SETUP_EXCEPT', handlers)
  786.         self.nextBlock(body)
  787.         self.setups.push((EXCEPT, body))
  788.         self.visit(node.body)
  789.         self.emit('POP_BLOCK')
  790.         self.setups.pop()
  791.         self.emit('JUMP_FORWARD', lElse)
  792.         self.startBlock(handlers)
  793.         last = len(node.handlers) - 1
  794.         for i in range(len(node.handlers)):
  795.             (expr, target, body) = node.handlers[i]
  796.             self.set_lineno(expr)
  797.             if expr:
  798.                 self.emit('DUP_TOP')
  799.                 self.visit(expr)
  800.                 self.emit('COMPARE_OP', 'exception match')
  801.                 next = self.newBlock()
  802.                 self.emit('JUMP_IF_FALSE', next)
  803.                 self.nextBlock()
  804.                 self.emit('POP_TOP')
  805.             
  806.             self.emit('POP_TOP')
  807.             if target:
  808.                 self.visit(target)
  809.             else:
  810.                 self.emit('POP_TOP')
  811.             self.emit('POP_TOP')
  812.             self.visit(body)
  813.             self.emit('JUMP_FORWARD', end)
  814.             if expr:
  815.                 self.nextBlock(next)
  816.             else:
  817.                 self.nextBlock()
  818.             if expr:
  819.                 self.emit('POP_TOP')
  820.                 continue
  821.         
  822.         self.emit('END_FINALLY')
  823.         if node.else_:
  824.             self.nextBlock(lElse)
  825.             self.visit(node.else_)
  826.         
  827.         self.nextBlock(end)
  828.  
  829.     
  830.     def visitTryFinally(self, node):
  831.         body = self.newBlock()
  832.         final = self.newBlock()
  833.         self.set_lineno(node)
  834.         self.emit('SETUP_FINALLY', final)
  835.         self.nextBlock(body)
  836.         self.setups.push((TRY_FINALLY, body))
  837.         self.visit(node.body)
  838.         self.emit('POP_BLOCK')
  839.         self.setups.pop()
  840.         self.emit('LOAD_CONST', None)
  841.         self.nextBlock(final)
  842.         self.setups.push((END_FINALLY, final))
  843.         self.visit(node.final)
  844.         self.emit('END_FINALLY')
  845.         self.setups.pop()
  846.  
  847.     
  848.     def visitDiscard(self, node):
  849.         self.set_lineno(node)
  850.         self.visit(node.expr)
  851.         self.emit('POP_TOP')
  852.  
  853.     
  854.     def visitConst(self, node):
  855.         self.emit('LOAD_CONST', node.value)
  856.  
  857.     
  858.     def visitKeyword(self, node):
  859.         self.emit('LOAD_CONST', node.name)
  860.         self.visit(node.expr)
  861.  
  862.     
  863.     def visitGlobal(self, node):
  864.         pass
  865.  
  866.     
  867.     def visitName(self, node):
  868.         self.set_lineno(node)
  869.         self.loadName(node.name)
  870.  
  871.     
  872.     def visitPass(self, node):
  873.         self.set_lineno(node)
  874.  
  875.     
  876.     def visitImport(self, node):
  877.         self.set_lineno(node)
  878.         for name, alias in node.names:
  879.             if VERSION > 1:
  880.                 self.emit('LOAD_CONST', None)
  881.             
  882.             self.emit('IMPORT_NAME', name)
  883.             mod = name.split('.')[0]
  884.             if alias:
  885.                 self._resolveDots(name)
  886.                 self.storeName(alias)
  887.                 continue
  888.             self.storeName(mod)
  889.         
  890.  
  891.     
  892.     def visitFrom(self, node):
  893.         self.set_lineno(node)
  894.         fromlist = map((lambda .0: (name, alias) = .0name), node.names)
  895.         if VERSION > 1:
  896.             self.emit('LOAD_CONST', tuple(fromlist))
  897.         
  898.         self.emit('IMPORT_NAME', node.modname)
  899.         for name, alias in node.names:
  900.             if VERSION > 1:
  901.                 if name == '*':
  902.                     self.namespace = 0
  903.                     self.emit('IMPORT_STAR')
  904.                     return None
  905.                 else:
  906.                     self.emit('IMPORT_FROM', name)
  907.                     self._resolveDots(name)
  908.                     if not alias:
  909.                         pass
  910.                     self.storeName(name)
  911.             name == '*'
  912.             self.emit('IMPORT_FROM', name)
  913.         
  914.         self.emit('POP_TOP')
  915.  
  916.     
  917.     def _resolveDots(self, name):
  918.         elts = name.split('.')
  919.         if len(elts) == 1:
  920.             return None
  921.         
  922.         for elt in elts[1:]:
  923.             self.emit('LOAD_ATTR', elt)
  924.         
  925.  
  926.     
  927.     def visitGetattr(self, node):
  928.         self.visit(node.expr)
  929.         self.emit('LOAD_ATTR', self.mangle(node.attrname))
  930.  
  931.     
  932.     def visitAssign(self, node):
  933.         self.set_lineno(node)
  934.         self.visit(node.expr)
  935.         dups = len(node.nodes) - 1
  936.         for i in range(len(node.nodes)):
  937.             elt = node.nodes[i]
  938.             if i < dups:
  939.                 self.emit('DUP_TOP')
  940.             
  941.             if isinstance(elt, ast.Node):
  942.                 self.visit(elt)
  943.                 continue
  944.         
  945.  
  946.     
  947.     def visitAssName(self, node):
  948.         if node.flags == 'OP_ASSIGN':
  949.             self.storeName(node.name)
  950.         elif node.flags == 'OP_DELETE':
  951.             self.set_lineno(node)
  952.             self.delName(node.name)
  953.         else:
  954.             print 'oops', node.flags
  955.  
  956.     
  957.     def visitAssAttr(self, node):
  958.         self.visit(node.expr)
  959.         if node.flags == 'OP_ASSIGN':
  960.             self.emit('STORE_ATTR', self.mangle(node.attrname))
  961.         elif node.flags == 'OP_DELETE':
  962.             self.emit('DELETE_ATTR', self.mangle(node.attrname))
  963.         else:
  964.             print 'warning: unexpected flags:', node.flags
  965.             print node
  966.  
  967.     
  968.     def _visitAssSequence(self, node, op = 'UNPACK_SEQUENCE'):
  969.         if findOp(node) != 'OP_DELETE':
  970.             self.emit(op, len(node.nodes))
  971.         
  972.         for child in node.nodes:
  973.             self.visit(child)
  974.         
  975.  
  976.     if VERSION > 1:
  977.         visitAssTuple = _visitAssSequence
  978.         visitAssList = _visitAssSequence
  979.     else:
  980.         
  981.         def visitAssTuple(self, node):
  982.             self._visitAssSequence(node, 'UNPACK_TUPLE')
  983.  
  984.         
  985.         def visitAssList(self, node):
  986.             self._visitAssSequence(node, 'UNPACK_LIST')
  987.  
  988.     
  989.     def visitAugAssign(self, node):
  990.         self.set_lineno(node)
  991.         aug_node = wrap_aug(node.node)
  992.         self.visit(aug_node, 'load')
  993.         self.visit(node.expr)
  994.         self.emit(self._augmented_opcode[node.op])
  995.         self.visit(aug_node, 'store')
  996.  
  997.     _augmented_opcode = {
  998.         '+=': 'INPLACE_ADD',
  999.         '-=': 'INPLACE_SUBTRACT',
  1000.         '*=': 'INPLACE_MULTIPLY',
  1001.         '/=': 'INPLACE_DIVIDE',
  1002.         '//=': 'INPLACE_FLOOR_DIVIDE',
  1003.         '%=': 'INPLACE_MODULO',
  1004.         '**=': 'INPLACE_POWER',
  1005.         '>>=': 'INPLACE_RSHIFT',
  1006.         '<<=': 'INPLACE_LSHIFT',
  1007.         '&=': 'INPLACE_AND',
  1008.         '^=': 'INPLACE_XOR',
  1009.         '|=': 'INPLACE_OR' }
  1010.     
  1011.     def visitAugName(self, node, mode):
  1012.         if mode == 'load':
  1013.             self.loadName(node.name)
  1014.         elif mode == 'store':
  1015.             self.storeName(node.name)
  1016.         
  1017.  
  1018.     
  1019.     def visitAugGetattr(self, node, mode):
  1020.         if mode == 'load':
  1021.             self.visit(node.expr)
  1022.             self.emit('DUP_TOP')
  1023.             self.emit('LOAD_ATTR', self.mangle(node.attrname))
  1024.         elif mode == 'store':
  1025.             self.emit('ROT_TWO')
  1026.             self.emit('STORE_ATTR', self.mangle(node.attrname))
  1027.         
  1028.  
  1029.     
  1030.     def visitAugSlice(self, node, mode):
  1031.         if mode == 'load':
  1032.             self.visitSlice(node, 1)
  1033.         elif mode == 'store':
  1034.             slice = 0
  1035.             if node.lower:
  1036.                 slice = slice | 1
  1037.             
  1038.             if node.upper:
  1039.                 slice = slice | 2
  1040.             
  1041.             if slice == 0:
  1042.                 self.emit('ROT_TWO')
  1043.             elif slice == 3:
  1044.                 self.emit('ROT_FOUR')
  1045.             else:
  1046.                 self.emit('ROT_THREE')
  1047.             self.emit('STORE_SLICE+%d' % slice)
  1048.         
  1049.  
  1050.     
  1051.     def visitAugSubscript(self, node, mode):
  1052.         if len(node.subs) > 1:
  1053.             raise SyntaxError, 'augmented assignment to tuple is not possible'
  1054.         
  1055.         if mode == 'load':
  1056.             self.visitSubscript(node, 1)
  1057.         elif mode == 'store':
  1058.             self.emit('ROT_THREE')
  1059.             self.emit('STORE_SUBSCR')
  1060.         
  1061.  
  1062.     
  1063.     def visitExec(self, node):
  1064.         self.visit(node.expr)
  1065.         if node.locals is None:
  1066.             self.emit('LOAD_CONST', None)
  1067.         else:
  1068.             self.visit(node.locals)
  1069.         if node.globals is None:
  1070.             self.emit('DUP_TOP')
  1071.         else:
  1072.             self.visit(node.globals)
  1073.         self.emit('EXEC_STMT')
  1074.  
  1075.     
  1076.     def visitCallFunc(self, node):
  1077.         pos = 0
  1078.         kw = 0
  1079.         self.set_lineno(node)
  1080.         self.visit(node.node)
  1081.         for arg in node.args:
  1082.             self.visit(arg)
  1083.             if isinstance(arg, ast.Keyword):
  1084.                 kw = kw + 1
  1085.                 continue
  1086.             pos = pos + 1
  1087.         
  1088.         if node.star_args is not None:
  1089.             self.visit(node.star_args)
  1090.         
  1091.         if node.dstar_args is not None:
  1092.             self.visit(node.dstar_args)
  1093.         
  1094.         have_star = node.star_args is not None
  1095.         have_dstar = node.dstar_args is not None
  1096.         opcode = callfunc_opcode_info[(have_star, have_dstar)]
  1097.         self.emit(opcode, kw << 8 | pos)
  1098.  
  1099.     
  1100.     def visitPrint(self, node, newline = 0):
  1101.         self.set_lineno(node)
  1102.         if node.dest:
  1103.             self.visit(node.dest)
  1104.         
  1105.         for child in node.nodes:
  1106.             if node.dest:
  1107.                 self.emit('DUP_TOP')
  1108.             
  1109.             self.visit(child)
  1110.             if node.dest:
  1111.                 self.emit('ROT_TWO')
  1112.                 self.emit('PRINT_ITEM_TO')
  1113.                 continue
  1114.             self.emit('PRINT_ITEM')
  1115.         
  1116.         if node.dest and not newline:
  1117.             self.emit('POP_TOP')
  1118.         
  1119.  
  1120.     
  1121.     def visitPrintnl(self, node):
  1122.         self.visitPrint(node, newline = 1)
  1123.         if node.dest:
  1124.             self.emit('PRINT_NEWLINE_TO')
  1125.         else:
  1126.             self.emit('PRINT_NEWLINE')
  1127.  
  1128.     
  1129.     def visitReturn(self, node):
  1130.         self.set_lineno(node)
  1131.         self.visit(node.value)
  1132.         self.emit('RETURN_VALUE')
  1133.  
  1134.     
  1135.     def visitYield(self, node):
  1136.         self.set_lineno(node)
  1137.         self.visit(node.value)
  1138.         self.emit('YIELD_VALUE')
  1139.  
  1140.     
  1141.     def visitSlice(self, node, aug_flag = None):
  1142.         self.visit(node.expr)
  1143.         slice = 0
  1144.         if node.lower:
  1145.             self.visit(node.lower)
  1146.             slice = slice | 1
  1147.         
  1148.         if node.upper:
  1149.             self.visit(node.upper)
  1150.             slice = slice | 2
  1151.         
  1152.         if aug_flag:
  1153.             if slice == 0:
  1154.                 self.emit('DUP_TOP')
  1155.             elif slice == 3:
  1156.                 self.emit('DUP_TOPX', 3)
  1157.             else:
  1158.                 self.emit('DUP_TOPX', 2)
  1159.         
  1160.         if node.flags == 'OP_APPLY':
  1161.             self.emit('SLICE+%d' % slice)
  1162.         elif node.flags == 'OP_ASSIGN':
  1163.             self.emit('STORE_SLICE+%d' % slice)
  1164.         elif node.flags == 'OP_DELETE':
  1165.             self.emit('DELETE_SLICE+%d' % slice)
  1166.         else:
  1167.             print 'weird slice', node.flags
  1168.             raise 
  1169.  
  1170.     
  1171.     def visitSubscript(self, node, aug_flag = None):
  1172.         self.visit(node.expr)
  1173.         for sub in node.subs:
  1174.             self.visit(sub)
  1175.         
  1176.         if aug_flag:
  1177.             self.emit('DUP_TOPX', 2)
  1178.         
  1179.         if len(node.subs) > 1:
  1180.             self.emit('BUILD_TUPLE', len(node.subs))
  1181.         
  1182.         if node.flags == 'OP_APPLY':
  1183.             self.emit('BINARY_SUBSCR')
  1184.         elif node.flags == 'OP_ASSIGN':
  1185.             self.emit('STORE_SUBSCR')
  1186.         elif node.flags == 'OP_DELETE':
  1187.             self.emit('DELETE_SUBSCR')
  1188.         
  1189.  
  1190.     
  1191.     def binaryOp(self, node, op):
  1192.         self.visit(node.left)
  1193.         self.visit(node.right)
  1194.         self.emit(op)
  1195.  
  1196.     
  1197.     def visitAdd(self, node):
  1198.         return self.binaryOp(node, 'BINARY_ADD')
  1199.  
  1200.     
  1201.     def visitSub(self, node):
  1202.         return self.binaryOp(node, 'BINARY_SUBTRACT')
  1203.  
  1204.     
  1205.     def visitMul(self, node):
  1206.         return self.binaryOp(node, 'BINARY_MULTIPLY')
  1207.  
  1208.     
  1209.     def visitDiv(self, node):
  1210.         return self.binaryOp(node, self._div_op)
  1211.  
  1212.     
  1213.     def visitFloorDiv(self, node):
  1214.         return self.binaryOp(node, 'BINARY_FLOOR_DIVIDE')
  1215.  
  1216.     
  1217.     def visitMod(self, node):
  1218.         return self.binaryOp(node, 'BINARY_MODULO')
  1219.  
  1220.     
  1221.     def visitPower(self, node):
  1222.         return self.binaryOp(node, 'BINARY_POWER')
  1223.  
  1224.     
  1225.     def visitLeftShift(self, node):
  1226.         return self.binaryOp(node, 'BINARY_LSHIFT')
  1227.  
  1228.     
  1229.     def visitRightShift(self, node):
  1230.         return self.binaryOp(node, 'BINARY_RSHIFT')
  1231.  
  1232.     
  1233.     def unaryOp(self, node, op):
  1234.         self.visit(node.expr)
  1235.         self.emit(op)
  1236.  
  1237.     
  1238.     def visitInvert(self, node):
  1239.         return self.unaryOp(node, 'UNARY_INVERT')
  1240.  
  1241.     
  1242.     def visitUnarySub(self, node):
  1243.         return self.unaryOp(node, 'UNARY_NEGATIVE')
  1244.  
  1245.     
  1246.     def visitUnaryAdd(self, node):
  1247.         return self.unaryOp(node, 'UNARY_POSITIVE')
  1248.  
  1249.     
  1250.     def visitUnaryInvert(self, node):
  1251.         return self.unaryOp(node, 'UNARY_INVERT')
  1252.  
  1253.     
  1254.     def visitNot(self, node):
  1255.         return self.unaryOp(node, 'UNARY_NOT')
  1256.  
  1257.     
  1258.     def visitBackquote(self, node):
  1259.         return self.unaryOp(node, 'UNARY_CONVERT')
  1260.  
  1261.     
  1262.     def bitOp(self, nodes, op):
  1263.         self.visit(nodes[0])
  1264.         for node in nodes[1:]:
  1265.             self.visit(node)
  1266.             self.emit(op)
  1267.         
  1268.  
  1269.     
  1270.     def visitBitand(self, node):
  1271.         return self.bitOp(node.nodes, 'BINARY_AND')
  1272.  
  1273.     
  1274.     def visitBitor(self, node):
  1275.         return self.bitOp(node.nodes, 'BINARY_OR')
  1276.  
  1277.     
  1278.     def visitBitxor(self, node):
  1279.         return self.bitOp(node.nodes, 'BINARY_XOR')
  1280.  
  1281.     
  1282.     def visitEllipsis(self, node):
  1283.         self.emit('LOAD_CONST', Ellipsis)
  1284.  
  1285.     
  1286.     def visitTuple(self, node):
  1287.         self.set_lineno(node)
  1288.         for elt in node.nodes:
  1289.             self.visit(elt)
  1290.         
  1291.         self.emit('BUILD_TUPLE', len(node.nodes))
  1292.  
  1293.     
  1294.     def visitList(self, node):
  1295.         self.set_lineno(node)
  1296.         for elt in node.nodes:
  1297.             self.visit(elt)
  1298.         
  1299.         self.emit('BUILD_LIST', len(node.nodes))
  1300.  
  1301.     
  1302.     def visitSliceobj(self, node):
  1303.         for child in node.nodes:
  1304.             self.visit(child)
  1305.         
  1306.         self.emit('BUILD_SLICE', len(node.nodes))
  1307.  
  1308.     
  1309.     def visitDict(self, node):
  1310.         self.set_lineno(node)
  1311.         self.emit('BUILD_MAP', 0)
  1312.         for k, v in node.items:
  1313.             self.emit('DUP_TOP')
  1314.             self.visit(k)
  1315.             self.visit(v)
  1316.             self.emit('ROT_THREE')
  1317.             self.emit('STORE_SUBSCR')
  1318.         
  1319.  
  1320.  
  1321.  
  1322. class NestedScopeMixin:
  1323.     '''Defines initClass() for nested scoping (Python 2.2-compatible)'''
  1324.     
  1325.     def initClass(self):
  1326.         self.__class__.NameFinder = LocalNameFinder
  1327.         self.__class__.FunctionGen = FunctionCodeGenerator
  1328.         self.__class__.ClassGen = ClassCodeGenerator
  1329.  
  1330.  
  1331.  
  1332. class ModuleCodeGenerator(NestedScopeMixin, CodeGenerator):
  1333.     __super_init = CodeGenerator.__init__
  1334.     scopes = None
  1335.     
  1336.     def __init__(self, tree):
  1337.         self.graph = pyassem.PyFlowGraph('<module>', tree.filename)
  1338.         self.futures = future.find_futures(tree)
  1339.         self._ModuleCodeGenerator__super_init()
  1340.         walk(tree, self)
  1341.  
  1342.     
  1343.     def get_module(self):
  1344.         return self
  1345.  
  1346.  
  1347.  
  1348. class ExpressionCodeGenerator(NestedScopeMixin, CodeGenerator):
  1349.     __super_init = CodeGenerator.__init__
  1350.     scopes = None
  1351.     futures = ()
  1352.     
  1353.     def __init__(self, tree):
  1354.         self.graph = pyassem.PyFlowGraph('<expression>', tree.filename)
  1355.         self._ExpressionCodeGenerator__super_init()
  1356.         walk(tree, self)
  1357.  
  1358.     
  1359.     def get_module(self):
  1360.         return self
  1361.  
  1362.  
  1363.  
  1364. class InteractiveCodeGenerator(NestedScopeMixin, CodeGenerator):
  1365.     __super_init = CodeGenerator.__init__
  1366.     scopes = None
  1367.     futures = ()
  1368.     
  1369.     def __init__(self, tree):
  1370.         self.graph = pyassem.PyFlowGraph('<interactive>', tree.filename)
  1371.         self._InteractiveCodeGenerator__super_init()
  1372.         self.set_lineno(tree)
  1373.         walk(tree, self)
  1374.         self.emit('RETURN_VALUE')
  1375.  
  1376.     
  1377.     def get_module(self):
  1378.         return self
  1379.  
  1380.     
  1381.     def visitDiscard(self, node):
  1382.         self.visit(node.expr)
  1383.         self.emit('PRINT_EXPR')
  1384.  
  1385.  
  1386.  
  1387. class AbstractFunctionCode:
  1388.     optimized = 1
  1389.     lambdaCount = 0
  1390.     
  1391.     def __init__(self, func, scopes, isLambda, class_name, mod):
  1392.         self.class_name = class_name
  1393.         self.module = mod
  1394.         if isLambda:
  1395.             klass = FunctionCodeGenerator
  1396.             name = '<lambda.%d>' % klass.lambdaCount
  1397.             klass.lambdaCount = klass.lambdaCount + 1
  1398.         else:
  1399.             name = func.name
  1400.         (args, hasTupleArg) = generateArgList(func.argnames)
  1401.         self.graph = pyassem.PyFlowGraph(name, func.filename, args, optimized = 1)
  1402.         self.isLambda = isLambda
  1403.         self.super_init()
  1404.         if not isLambda and func.doc:
  1405.             self.setDocstring(func.doc)
  1406.         
  1407.         lnf = walk(func.code, self.NameFinder(args), verbose = 0)
  1408.         self.locals.push(lnf.getLocals())
  1409.         if func.varargs:
  1410.             self.graph.setFlag(CO_VARARGS)
  1411.         
  1412.         if func.kwargs:
  1413.             self.graph.setFlag(CO_VARKEYWORDS)
  1414.         
  1415.         self.set_lineno(func)
  1416.         if hasTupleArg:
  1417.             self.generateArgUnpack(func.argnames)
  1418.         
  1419.  
  1420.     
  1421.     def get_module(self):
  1422.         return self.module
  1423.  
  1424.     
  1425.     def finish(self):
  1426.         self.graph.startExitBlock()
  1427.         if not self.isLambda:
  1428.             self.emit('LOAD_CONST', None)
  1429.         
  1430.         self.emit('RETURN_VALUE')
  1431.  
  1432.     
  1433.     def generateArgUnpack(self, args):
  1434.         for i in range(len(args)):
  1435.             arg = args[i]
  1436.             if type(arg) == types.TupleType:
  1437.                 self.emit('LOAD_FAST', '.%d' % i * 2)
  1438.                 self.unpackSequence(arg)
  1439.                 continue
  1440.         
  1441.  
  1442.     
  1443.     def unpackSequence(self, tup):
  1444.         if VERSION > 1:
  1445.             self.emit('UNPACK_SEQUENCE', len(tup))
  1446.         else:
  1447.             self.emit('UNPACK_TUPLE', len(tup))
  1448.         for elt in tup:
  1449.             if type(elt) == types.TupleType:
  1450.                 self.unpackSequence(elt)
  1451.                 continue
  1452.             self._nameOp('STORE', elt)
  1453.         
  1454.  
  1455.     unpackTuple = unpackSequence
  1456.  
  1457.  
  1458. class FunctionCodeGenerator(NestedScopeMixin, AbstractFunctionCode, CodeGenerator):
  1459.     super_init = CodeGenerator.__init__
  1460.     scopes = None
  1461.     __super_init = AbstractFunctionCode.__init__
  1462.     
  1463.     def __init__(self, func, scopes, isLambda, class_name, mod):
  1464.         self.scopes = scopes
  1465.         self.scope = scopes[func]
  1466.         self._FunctionCodeGenerator__super_init(func, scopes, isLambda, class_name, mod)
  1467.         self.graph.setFreeVars(self.scope.get_free_vars())
  1468.         self.graph.setCellVars(self.scope.get_cell_vars())
  1469.         if self.scope.generator is not None:
  1470.             self.graph.setFlag(CO_GENERATOR)
  1471.         
  1472.  
  1473.  
  1474.  
  1475. class GenExprCodeGenerator(NestedScopeMixin, AbstractFunctionCode, CodeGenerator):
  1476.     super_init = CodeGenerator.__init__
  1477.     scopes = None
  1478.     __super_init = AbstractFunctionCode.__init__
  1479.     
  1480.     def __init__(self, gexp, scopes, class_name, mod):
  1481.         self.scopes = scopes
  1482.         self.scope = scopes[gexp]
  1483.         self._GenExprCodeGenerator__super_init(gexp, scopes, 1, class_name, mod)
  1484.         self.graph.setFreeVars(self.scope.get_free_vars())
  1485.         self.graph.setCellVars(self.scope.get_cell_vars())
  1486.         self.graph.setFlag(CO_GENERATOR)
  1487.  
  1488.  
  1489.  
  1490. class AbstractClassCode:
  1491.     
  1492.     def __init__(self, klass, scopes, module):
  1493.         self.class_name = klass.name
  1494.         self.module = module
  1495.         self.graph = pyassem.PyFlowGraph(klass.name, klass.filename, optimized = 0, klass = 1)
  1496.         self.super_init()
  1497.         lnf = walk(klass.code, self.NameFinder(), verbose = 0)
  1498.         self.locals.push(lnf.getLocals())
  1499.         self.graph.setFlag(CO_NEWLOCALS)
  1500.         if klass.doc:
  1501.             self.setDocstring(klass.doc)
  1502.         
  1503.  
  1504.     
  1505.     def get_module(self):
  1506.         return self.module
  1507.  
  1508.     
  1509.     def finish(self):
  1510.         self.graph.startExitBlock()
  1511.         self.emit('LOAD_LOCALS')
  1512.         self.emit('RETURN_VALUE')
  1513.  
  1514.  
  1515.  
  1516. class ClassCodeGenerator(NestedScopeMixin, AbstractClassCode, CodeGenerator):
  1517.     super_init = CodeGenerator.__init__
  1518.     scopes = None
  1519.     __super_init = AbstractClassCode.__init__
  1520.     
  1521.     def __init__(self, klass, scopes, module):
  1522.         self.scopes = scopes
  1523.         self.scope = scopes[klass]
  1524.         self._ClassCodeGenerator__super_init(klass, scopes, module)
  1525.         self.graph.setFreeVars(self.scope.get_free_vars())
  1526.         self.graph.setCellVars(self.scope.get_cell_vars())
  1527.         self.set_lineno(klass)
  1528.         self.emit('LOAD_GLOBAL', '__name__')
  1529.         self.storeName('__module__')
  1530.         if klass.doc:
  1531.             self.emit('LOAD_CONST', klass.doc)
  1532.             self.storeName('__doc__')
  1533.         
  1534.  
  1535.  
  1536.  
  1537. def generateArgList(arglist):
  1538.     '''Generate an arg list marking TupleArgs'''
  1539.     args = []
  1540.     extra = []
  1541.     count = 0
  1542.     for i in range(len(arglist)):
  1543.         elt = arglist[i]
  1544.         if type(elt) == types.StringType:
  1545.             args.append(elt)
  1546.             continue
  1547.         if type(elt) == types.TupleType:
  1548.             args.append(TupleArg(i * 2, elt))
  1549.             extra.extend(misc.flatten(elt))
  1550.             count = count + 1
  1551.             continue
  1552.         raise ValueError, 'unexpect argument type:', elt
  1553.     
  1554.     return (args + extra, count)
  1555.  
  1556.  
  1557. def findOp(node):
  1558.     '''Find the op (DELETE, LOAD, STORE) in an AssTuple tree'''
  1559.     v = OpFinder()
  1560.     walk(node, v, verbose = 0)
  1561.     return v.op
  1562.  
  1563.  
  1564. class OpFinder:
  1565.     
  1566.     def __init__(self):
  1567.         self.op = None
  1568.  
  1569.     
  1570.     def visitAssName(self, node):
  1571.         if self.op is None:
  1572.             self.op = node.flags
  1573.         elif self.op != node.flags:
  1574.             raise ValueError, 'mixed ops in stmt'
  1575.         
  1576.  
  1577.     visitAssAttr = visitAssName
  1578.     visitSubscript = visitAssName
  1579.  
  1580.  
  1581. class Delegator:
  1582.     '''Base class to support delegation for augmented assignment nodes
  1583.  
  1584.     To generator code for augmented assignments, we use the following
  1585.     wrapper classes.  In visitAugAssign, the left-hand expression node
  1586.     is visited twice.  The first time the visit uses the normal method
  1587.     for that node .  The second time the visit uses a different method
  1588.     that generates the appropriate code to perform the assignment.
  1589.     These delegator classes wrap the original AST nodes in order to
  1590.     support the variant visit methods.
  1591.     '''
  1592.     
  1593.     def __init__(self, obj):
  1594.         self.obj = obj
  1595.  
  1596.     
  1597.     def __getattr__(self, attr):
  1598.         return getattr(self.obj, attr)
  1599.  
  1600.  
  1601.  
  1602. class AugGetattr(Delegator):
  1603.     pass
  1604.  
  1605.  
  1606. class AugName(Delegator):
  1607.     pass
  1608.  
  1609.  
  1610. class AugSlice(Delegator):
  1611.     pass
  1612.  
  1613.  
  1614. class AugSubscript(Delegator):
  1615.     pass
  1616.  
  1617. wrapper = {
  1618.     ast.Getattr: AugGetattr,
  1619.     ast.Name: AugName,
  1620.     ast.Slice: AugSlice,
  1621.     ast.Subscript: AugSubscript }
  1622.  
  1623. def wrap_aug(node):
  1624.     return wrapper[node.__class__](node)
  1625.  
  1626. if __name__ == '__main__':
  1627.     for file in sys.argv[1:]:
  1628.         compileFile(file)
  1629.     
  1630.  
  1631.